﻿#pragma once
#include <iostream>
#include "Time.h"
using namespace std;

//class Date
//{
//public:
//    //函数体内赋值：
//    //Date(int year, int month, int day)
//    //{
//    //    _year = year;
//    //    _month = month;
//    //    _day = day;
//    //}
//    //初始化列表：
//    Date(int& rx, int year = 2025, int month = 4, int day = 23)
//        :_year(year)
//        , _month(month)
//        , _day(day)
//        , _n(1)
//        , _rx(rx)
//        , _t(1)
//        , _ptr((int*)malloc(12))
//    {
//        //函数体内赋值
//        if (nullptr == _ptr)
//        {
//            perror("malloc fail");
//        }
//        else
//        {
//            memset(_ptr, 0, 12);
//        }
//    }
//
//    void Print() const
//    {
//        cout << _year << '/' << _month << '/' << _day << '/' << endl;
//    }
//private:
//    //C++11
//    //声明，缺省值 -> 初始化列表
//    int _year = 1;
//    int _month = 1;
//    int _day = 1;
//    //表达式
//    int* _ptr = (int*)malloc(12);
//
//    //必须在初始化列表里初始化：
//    //常量限定类型的对象
//    //引用对象
//    //没有合适的默认构造函数可用的自定义类型对象
//    const int _n;//const 类型必须在初始化列表初始化
//    int& _rx; //引用 类型必须在初始化列表初始化
//    Time _t;//对于自定义类型，没有该类型若是没有默认构造，则必须通过初始化列表初始化
//
//};

//C++11支持在成员变量声明的位置给缺省值，
// 这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。
//class Date
//{
//public:
//    //非默认构造
//    Date(int year, int month)
//        : _year(year)
//        , _month(month)
//        //即使没有显示地初始化成员变量，初始化列表也会走一遍成员变量的缺省声明
//    {}
//        
//    void Print()
//    {
//        cout << _year << '/' << _month << '/' << _day << endl;
//        cout << _ptr << endl;
//        cout << _t.getHour() << endl;
//    }
//private:
//    //C++11
//    //声明，缺省值 -> 初始化列表
//    int _year = 1;
//    int _month = 1;
//    int _day;
//
//    //缺省声明可以是表达式
//    //int* _ptr = (int*)malloc(12);
//    int* _ptr;
//
//    //自定义类型
//    Time _t;
//};

//5.初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持⼀致。
//class A
//{
//public:
//	A(int a)//构造函数不负责开空间，仅负责初始化
//		: _a1(a)
//		, _a2(_a1)
//	{}
//
//	void Print()
//	{
//		cout << _a1 << ' ' << _a2 << endl;
//		cout << "&_a1:" << &_a1 << endl;
//		cout << "&_a2:" << &_a2 << endl;
//	}
//private:
//	int _a2 = 2;
//	int _a1 = 2;
//};

//static
//class A
//{
//public:
//	A()//构造
//	{
//		++_scount;
//	}
//	A(const A& a)//拷贝构造
//	{
//		++_scount;
//	}
//	//静态成员函数
//	static int getACount()
//	{
//		//_a++;//无法访问非静态成员变量
//		return _scount;
//	}
//	//非静态成员函数
//	//void Func()
//	//{
//	//	cout << _scount << _a <<  endl;
//	//}
//
//	~A()
//	{
//		--_scount;
//	}
//
//private:
//
//	//类里面声明，初始化要在全局域初始化
//	static int _scount;
//	//int _a;
//};


//class A
//{
//public:
//	A()
//	{
//		cout << "A()" << endl;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//};
//
//class B
//{
//public:
//	B()
//	{
//		cout << "B()" << endl;
//	}
//	~B()
//	{
//		cout << "~B()" << endl;
//	}
//};
//
//class C
//{
//public:
//	C()
//	{
//		cout << "C()" << endl;
//	}
//	~C()
//	{
//		cout << "~C()" << endl;
//	}
//};
//
//class D
//{
//public:
//	D()
//	{
//		cout << "D()" << endl;
//	}
//	~D()
//	{
//		cout << "~D()" << endl;
//	}
//};


//友元
////前置声明：
//class B;
//class C;
//
//
//class A
//{
//public:
//	void funca1(const B& bb)
//	{
//		cout << bb._b1 << endl;
//	}
//	void funca2(const C& cc)
//	{
//		cout << cc._c1;
//	}
//
//private:
//	int _a1 = 1;
//};
//
//class B
//{
//	friend class A;
//public:
//	void funcb1(const C& cc)
//	{
//		cout << cc._c1 << endl;
//	}
//
//private:
//	int _b1 = 1;
//};
//
//class C
//{
//	friend class B;
//public:
//
//private:
//	int _c1;
//};

//class A
//{
//public:
//    //默认情况下：内部类是外部类的友元，内部类可以随意访问外部类
//    class B
//    {
//    public:
//        void foo(const A& a)
//        {
//            cout << _k << endl;
//            cout << a._h << endl;
//        }
//
//    private:
//        int _b = 1;
//    };
//
//    //void Funca1(const B& bb)
//    //{
//    //    //cout << bb._b << endl;//默认情况下：外部类不是内部类友元，外部类无法访问内部类的私有和保护
//    //}
//
//
//private:
//    static int _k;
//    int _h = 1;
//};

//class A
//{
//	friend class B;
//public:
//	//默认构造函数
//	A(int a1 = 1, int a2 = 2)
//		: _a1(a1)
//		, _a2(a2)
//	{
//		cout << "A()" << endl;
//	}
//	//拷贝构造函数
//	A(const A& aa)
//		:_a1(aa._a1)
//	{
//		cout << "A(const A& aa)" << endl;
//	}
//	void Print()
//	{
//		cout << _a1 << endl;
//		cout << _a2 << endl;
//	}
//	//析构函数
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:
//	int _a1;
//	int _a2;
//};

//class B
//{
//public:
//	B(int b = 1)
//		:_b1(b)
//	{}
//	B(const A& a)
//		:_b1(a._a1)
//	{
//	}
//	void Print()
//	{
//		cout << _b1 << endl;
//	}
//
//
//private:
//	int _b1;
//};


class A
{
public:
	A(int a = 0)//默认构造
		:_a1(a)
	{
		cout << "A(int a = 1)" << endl;
	}
	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a1;
};